home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 1.toast / pc / sample code / graphics 2d / copybits vs. copymask / sampleinit.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-23  |  10.2 KB  |  229 lines
  1. /*
  2.     File:        SampleInit.c
  3.  
  4.     Contains:    Sample is an example application that demonstrates how to
  5.                 initialize the commonly used toolbox managers, operate 
  6.                 successfully under MultiFinder, handle desk accessories, 
  7.                 and create, grow, and zoom windows.
  8.     
  9.                 It does not by any means demonstrate all the techniques 
  10.                 you need for a large application. In particular, Sample 
  11.                 does not cover exception handling, multiple windows/documents, 
  12.                 sophisticated memory management, printing, or undo. All of 
  13.                 these are vital parts of a normal full-sized application.
  14.     
  15.                 This application is an example of the form of a Macintosh 
  16.                 application; it is NOT a template. It is NOT intended to be 
  17.                 used as a foundation for the next world-class, best-selling, 
  18.                 600K application. A stick figure drawing of the human body may 
  19.                 be a good example of the form for a painting, but that does not 
  20.                 mean it should be used as the basis for the next Mona Lisa.
  21.     
  22.                 We recommend that you review this program or TESample before 
  23.                 beginning a new application.
  24.  
  25.                 SetPort strategy:
  26.  
  27.                    Toolbox routines do not change the current port. In spite of this, in this
  28.                   program we use a strategy of calling SetPort whenever we want to draw or
  29.                    make calls which depend on the current port. This makes us less vulnerable
  30.                    to bugs in other software which might alter the current port (such as the
  31.                    bug (feature?) in many desk accessories which change the port on OpenDeskAcc).
  32.                    Hopefully, this also makes the routines from this program more self-contained,
  33.                    since they don't depend on the current port setting.
  34.     Written by:     
  35.  
  36.     Copyright:    Copyright © 1989-1999 by Apple Computer, Inc., All Rights Reserved.
  37.  
  38.                 You may incorporate this Apple sample source code into your program(s) without
  39.                 restriction. This Apple sample source code has been provided "AS IS" and the
  40.                 responsibility for its operation is yours. You are not permitted to redistribute
  41.                 this Apple sample source code as "Apple sample source code" after having made
  42.                 changes. If you're going to re-distribute the source, we require that you make
  43.                 it clear in the source that the code was descended from Apple sample source
  44.                 code, but that you've made changes.
  45.  
  46.     Change History (most recent first):
  47.                 7/9/1999    Karl Groethe    Updated for Metrowerks Codewarror Pro 2.1
  48.                 
  49.  
  50. */
  51.  
  52.  
  53.  
  54. #include <OSUtils.h>
  55. #include <Traps.h>
  56. #include "Sample.h"        /* bring in all the #defines for Sample */
  57.  
  58. /* The "g" prefix is used to emphasize that a variable is global. */
  59. /* All are extern since the variables are declared in the main segment. */
  60.  
  61. /* GMac is used to hold the result of a SysEnvirons call. This makes
  62.    it convenient for any routine to check the environment. */
  63. extern SysEnvRec    gMac;                /* set up by Initialize */
  64.  
  65. /* GHasWaitNextEvent is set at startup, and tells whether the WaitNextEvent
  66.    trap is available. If it is false, we know that we must call GetNextEvent. */
  67. extern Boolean        gHasWaitNextEvent;    /* set up by Initialize */
  68.  
  69. /* GInBackground is maintained by our osEvent handling routines. Any part of
  70.    the program can check it to find out if it is currently in the background. */
  71. extern Boolean        gInBackground;        /* maintained by Initialize and DoEvent */
  72.  
  73.  
  74. /* The following globals are the state of the window. If we supported more than
  75.    one window, they would be attatched to each document, rather than globals. */
  76.  
  77. /* GStopped tells whether the stop light is currently on stop or go. */
  78. extern Boolean        gStopped;            /* maintained by Initialize and SetLight */
  79.  
  80. /* GStopRect and gGoRect are the rectangles of the two stop lights in the window. */
  81. extern Rect        gStopRect;            /* set up by Initialize */
  82. extern Rect        gGoRect;            /* set up by Initialize */
  83.  
  84.  
  85. /*    Set up the whole world, including global variables, Toolbox managers,
  86.     and menus. We also create our one application window at this time.
  87.     Since window storage is non-relocateable, how and when to allocate space
  88.     for windows is very important so that heap fragmentation does not occur.
  89.     Because Sample has only one window and it is only disposed when the application
  90.     quits, we will allocate its space here, before anything that might be a locked
  91.     relocatable object gets into the heap. This way, we can force the storage to be
  92.     in the lowest memory available in the heap. Window storage can differ widely
  93.     amongst applications depending on how many windows are created and disposed. */
  94.  
  95. /*    1.01 - The code that used to be part of ForceEnvirons has been moved into
  96.     this module. If an error is detected, instead of merely doing an ExitToShell,
  97.     which leaves the user without much to go on, we call AlertUser, which puts
  98.     up a simple alert that just says an error occurred and then calls ExitToShell.
  99.     Since there is no other cleanup needed at this point if an error is detected,
  100.     this form of error- handling is acceptable. If more sophisticated error recovery
  101.     is needed, an exception mechanism, such as is provided by Signals, can be used. */
  102.  
  103. void Initialize()
  104. {
  105.     Handle        menuBar;
  106.     DialogPtr    newDialogP;
  107.     long        total, contig;
  108.     EventRecord event;
  109.     short        count;
  110.  
  111.     gInBackground = false;
  112.  
  113.     InitGraf((Ptr) &qd.thePort);
  114.     InitFonts();
  115.     InitWindows();
  116.     InitMenus();
  117.     TEInit();
  118.     InitDialogs(nil);
  119.     InitCursor();
  120.     
  121.     /*    Call MPPOpen and ATPLoad at this point to initialize AppleTalk,
  122.          if you are using it. */
  123.     /*    NOTE -- It is no longer necessary, and actually unhealthy, to check
  124.         PortBUse and SPConfig before opening AppleTalk. The drivers are capable
  125.         of checking for port availability themselves. */
  126.     
  127.     /*    This next bit of code is necessary to allow the default button of our
  128.         alert be outlined.
  129.         1.02 - Changed to call EventAvail so that we don't lose some important
  130.         events. */
  131.      
  132.     for (count = 1; count <= 3; count++)
  133.         EventAvail(everyEvent, &event);
  134.     
  135.     /*    Ignore the error returned from SysEnvirons; even if an error occurred,
  136.         the SysEnvirons glue will fill in the SysEnvRec. You can save a redundant
  137.         call to SysEnvirons by calling it after initializing AppleTalk. */
  138.      
  139.     SysEnvirons(kSysEnvironsVersion, &gMac);
  140.     
  141.     /* Make sure that the machine has at least 128K ROMs. If it doesn't, exit. */
  142.     
  143.     if (gMac.machineType < 0) AlertUser();
  144.     
  145.     /*    1.02 - Move TrapAvailable call to after SysEnvirons so that we can tell
  146.         in TrapAvailable if a tool trap value is out of range. */
  147.         
  148.     gHasWaitNextEvent = TrapAvailable(_WaitNextEvent, ToolTrap);
  149.  
  150.     /*    1.01 - We used to make a check for memory at this point by examining ApplLimit,
  151.         ApplicZone, and StackSpace and comparing that to the minimum size we told
  152.         MultiFinder we needed. This did not work well because it assumed too much about
  153.         the relationship between what we asked MultiFinder for and what we would actually
  154.         get back, as well as how to measure it. Instead, we will use an alternate
  155.         method comprised of two steps. */
  156.      
  157.     /*    It is better to first check the size of the application heap against a value
  158.         that you have determined is the smallest heap the application can reasonably
  159.         work in. This number should be derived by examining the size of the heap that
  160.         is actually provided by MultiFinder when the minimum size requested is used.
  161.         The derivation of the minimum size requested from MultiFinder is described
  162.         in Sample.h. The check should be made because the preferred size can end up
  163.         being set smaller than the minimum size by the user. This extra check acts to
  164.         insure that your application is starting from a solid memory foundation. */
  165.      
  166.     if ((long) GetApplLimit() - (long) ApplicationZone() < kMinHeap) AlertUser();
  167.     
  168.     /*    Next, make sure that enough memory is free for your application to run. It
  169.         is possible for a situation to arise where the heap may have been of required
  170.         size, but a large scrap was loaded which left too little memory. To check for
  171.         this, call PurgeSpace and compare the result with a value that you have determined
  172.         is the minimum amount of free memory your application needs at initialization.
  173.         This number can be derived several different ways. One way that is fairly
  174.         straightforward is to run the application in the minimum size configuration
  175.         as described previously. Call PurgeSpace at initialization and examine the value
  176.         returned. However, you should make sure that this result is not being modified
  177.         by the scrap's presence. You can do that by calling ZeroScrap before calling
  178.         PurgeSpace. Make sure to remove that call before shipping, though. */
  179.     
  180.     /* ZeroScrap(); */
  181.  
  182.     PurgeSpace(&total, &contig);
  183.     if (total < kMinSpace) AlertUser();
  184.  
  185.     /*    The extra benefit to waiting until after the Toolbox Managers have been initialized
  186.         to check memory is that we can now give the user an alert to tell him/her what
  187.         happened. Although it is possible that the memory situation could be worsened by
  188.         displaying an alert, MultiFinder would gracefully exit the application with
  189.         an informative alert if memory became critical. Here we are acting more
  190.         in a preventative manner to avoid future disaster from low-memory problems. */
  191.  
  192.     newDialogP = GetNewDialog(rWindow, nil, (WindowPtr) -1);
  193.     if ( newDialogP == nil ) AlertUser();
  194.     SetPort(newDialogP);
  195.     TextFont(kFontIDGeneva);
  196.     TextSize(9);
  197.     TextFace(normal);
  198.  
  199.     menuBar = GetNewMBar(rMenuBar);            /* read menus into menu bar */
  200.     if ( menuBar == nil ) AlertUser();
  201.     SetMenuBar(menuBar);                    /* install menus */
  202.     DisposeHandle(menuBar);
  203.     AppendResMenu(GetMenuHandle(mApple), 'DRVR');    /* add DA names to Apple menu */
  204.     DrawMenuBar();
  205.  
  206.     gStopped = true;
  207. } /*Initialize*/
  208.  
  209.  
  210.  
  211. /*    Check to see if a given trap is implemented. This is only used by the
  212.     Initialize routine in this program, so we put it in the Initialize segment.
  213.     The recommended approach to see if a trap is implemented is to see if
  214.     the address of the trap routine is the same as the address of the
  215.     Unimplemented trap. */
  216. /*    1.02 - Needs to be called after call to SysEnvirons so that it can check
  217.     if a ToolTrap is out of range of a pre-MacII ROM. */
  218.  
  219. Boolean TrapAvailable(short tNumber, TrapType tType)
  220. {
  221.     if ( ( tType == ToolTrap ) &&
  222.         ( gMac.machineType > envMachUnknown ) &&
  223.         ( gMac.machineType < envMacII ) ) {        /* it's a 512KE, Plus, or SE */
  224.         tNumber = tNumber & 0x03FF;
  225.         if ( tNumber > 0x01FF )                    /* which means the tool traps */
  226.             tNumber = _Unimplemented;            /* only go to 0x01FF */
  227.     }
  228.     return NGetTrapAddress(tNumber, tType) != GetOSTrapAddress(_Unimplemented);
  229. } /*TrapAvailable*/